{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Анализ данных на Python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По материалам *Элен Теванян*\n",
    "\n",
    "Автор: Полина Полунина \n",
    "\n",
    "**18.02.2024**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Про Python\n",
    "\n",
    "**Python** - язык программирования общего назначения, т.е. на нем можно написать все, что угодно. \n",
    "\n",
    "1) Open-source, т.е. он свободно и бесплатно доступен <br>\n",
    "2) Много библиотек, т.е. кода, для работы со специфическими задачами. \n",
    "\n",
    "**Python** - это свободный интерпретируемый объектно-ориентированный расширяемый встраиваемый язык программирования очень высокого уровня (Г.Россум, Ф.Л.Дж.Дрейк, Д.С.Откидач \"Язык программирования Python\").\n",
    "\n",
    "Python - это язык, который могут читать и \"понимать\" разные программные средства.\n",
    "\n",
    "----------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Где мы сейчас\n",
    "\n",
    "Мы находимся в **Jupyter Notebook**. Это интерактивная среда, в которой можно не только писать код, а создавать полноценный аналитический документ с кодом, комментариями, графиками, формулами. \n",
    "\n",
    "Файл, в котором мы работаем сейчас, называется **ноутбуком**. Его стандартное расширение .ipynb, читать и запускать его можно через Jupyter Notebook. Но его можно скачать в виде html-страницы или pdf-документа."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Anaconda Navigator\n",
    "\n",
    "Это сборка инструментов для анализа данных на Python, она содержит в том числе  Jupyter Notebook, библиотеки для Python и другие инструменты.\n",
    "\n",
    "Среди наиболее популярных библиотек:\n",
    " - <a href=\"http://numpy.org\">Numpy</a> - это один из основных пакетов для научных вычислений. Он содержит функциональные средства для работы с многомерными массивами и высокоуровневыми математическими функциями.\n",
    " - <a href=\"http://numpy.org\">SciPy</a> - научные вычисления. Методы оптимизации, интегрирования, модули обработки сигналов и изображений, статистика, линейная алгебра, сплайны, кластеризация и многое другое. \n",
    " -  <a href=\"http://pandas.pydata.org/\">Pandas</a> - библиотека для обработки и анализа данных. Предназначена для данных разной природы - матричных, панельных данных, временных рядов. Претендует на звание самого мощного и гибкого средства для анализа данных с открытым исходным кодом.\n",
    " - <a href=\"http://scikit-learn.org/stable/\">Scikit-learn</a> - реализация очень многих методов машинного обучения и интеллекуального анализа данных (data mining) с отличной документацией. \n",
    " - <a href=\"http://http://matplotlib.org/\">matplotlib</a> - библиотека для визаулизации данных, в основном двухмерная графика."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Как устроен Jupyter Notebook\n",
    "\n",
    "- Любой ноутбук состоит из ячеек. Даже текущий текст написан в ячейке.<br>\n",
    "\n",
    "## Создание ячейки.\n",
    "- Чтобы создать новую ячейку, можно воспользоваться одной из следующих опций: <br> \n",
    "    1) воспользоваться кнопкой \"+\" на верхней панели управления;<br> \n",
    "    \n",
    "    2) с клавиатуры нажать на букву \"B\", и появится новая ячейка после текущей активной; <br> \n",
    "    3) с клавиатуры нажать на букву \"A\", и появится новая ячейка перед текущей активной. <br> \n",
    "\n",
    "## Изменение типа ячейки\n",
    "- Ячейки бывают двух типов: <br> \n",
    "    1) Кодовая<br>\n",
    "    2) Текстовая <br> <br> \n",
    "- Смена типа ячейки осуществляется через верхнюю панель управления, необходимо нажать на ячейку и выбрать ее тип\n",
    "\n",
    "## Редактирование ячейки\n",
    "\n",
    "- Ячейка, которая не активна, серого цвета\n",
    "- Ячейка активируется одним нажатием курсора и становится синего цвета\n",
    "- Ячейка переходит в режим редактирования двойным нажатием курсора и становится зеленого цвета\n",
    "\n",
    "## Запуск ячейки с кодом\n",
    "- Ячейка с кодом, которая еще не была ни разу запущена - слева в квадратных скобках [] пусто.\n",
    "\n",
    "- В последних версиях Jupyter Notebook при приближении к ячейке слева появляется кнопка проигрывания, которая запускает ячейку.\n",
    "\n",
    "- Запустить код можно также из панельной строки. Запускается код ячейки, которая была выбрана!\n",
    "\n",
    "- Если ячейка успешно запущена, то слева в квадратных скобках появляется число. Вот результат успешного выполнения команды:\n",
    "\n",
    "## Прерывание работы\n",
    "\n",
    "Иногда требуется искусственно остановить работу ячейки.\n",
    "\n",
    "- Можно нажать кнопку стоп при работе активной ячейки. Знак СТОП вверху.\n",
    "- Можно воспользоваться опцией в меню Kernel - Interrupt\n",
    "- Можно радикально \"перезагрузить\" ноутбук в меню Kernel - Restart and Clear Output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Основы Python \n",
    "\n",
    "Для прикладных целей важно овладеть несколькими аспектами:\n",
    "\n",
    "- Стандартные функции языка\n",
    "- Переменные и типы данных\n",
    "- Основные конструкции\n",
    "- Написание пользовательских функций\n",
    "- Загрузка и использование библиотек"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Стандартные функции языка\n",
    "\n",
    "Функции - это маленькие программки, которые умеют выполнять какую-то операцию <br />\n",
    "Функции <b>вызываются</b>, после имени функции следуют круглые скобки, в которых указываются <b>аргументы</b> (над каким объектом будет выполнена операция) и <b>параметры </b> (с какими условиями)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### print()\n",
    "Функция для вывода содержимого на экран. <br>\n",
    "**Обязательно**: передать хотя бы какой-то объект, который нужно напечатать.\n",
    "\n",
    "Ее полный синтаксис:\n",
    "\n",
    "print(*objects, sep=' ', end='\\n', file=sys.stdout, flush=False)¶\n",
    "- objects: один или несколько объектов для вывода, перечисленные через запятую\n",
    "- sep: разделитель между несколькими объектами; стандартно установлен пробел\n",
    "- end: окончание строки; стандартно установлен перевод на новую строчку '\\n'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5, 6, 7, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5, 6, 7, 8, sep='_')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('October')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 1\n",
    "\n",
    "Выведите на экран фразу \"Hello, world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Hello, world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### input()\n",
    "Функция для ввода данных в программу с клавиатуры. <br>\n",
    "Обязательных аргументов нет. Можно передавать строчку, которая будет выведена перед ячейкой ввода. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input()\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А здесь небольшое преобразование позволит вывести перед ячейкой ввода нужный текст"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input('Введите ваше имя: ')\n",
    "print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Арифметические операции\n",
    "- Сложение: +\n",
    "- Вычитание: -\n",
    "- Умножение: *\n",
    "- Деление: /\n",
    "- Возведение в степень: **\n",
    "- Целочисленное деление: //\n",
    "- Остаток от деления: %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Работаем с числами', 5, 'и', 2)\n",
    "print(5 + 2)\n",
    "print(5 - 2)\n",
    "print(5*2)\n",
    "print(5 / 2)\n",
    "print( 5 // 2)\n",
    "print('Результат остатка от деления:', 5 % 2)\n",
    "print('Результат возведения в степени:', 5**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 2\n",
    "\n",
    "Представим, что у нас в активе $100, которые можно инвестировать с 10%-ным ежегодным доходом. <br>\n",
    "Сколько денег мы заработаем через 7 лет? Выведите ответ на экран. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Переменные и типы переменных\n",
    "\n",
    "Результаты операций и манипуляций иногда нужно сохранять, поэтому мы определяем переменные - именованные объекты, которым присваиваем значения. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_2017 = 2000\n",
    "savings_2016 = 1800\n",
    "increase = ((2000 - 1800) / 1800)*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Вывести на печать % роста накоплений\n",
    "print(round(increase), '%', sep='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 3\n",
    "\n",
    "Представим, что у нас в активе $100, которые можно инвестировать с 10%-ным ежегодным доходом. <br>\n",
    "Сколько денег мы заработаем через 7 лет? \n",
    "\n",
    "- Создайте переменную savings со значением 100\n",
    "- Создайте переменную rate, которая отвечает за ежегодный рост\n",
    "- Сохраните результат вычисления в переменную result\n",
    "- Выведите на печать результаты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция **type** позволяет определить, какого типа переменная нам дана или какого типа переменную мы записали. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(savings_2017))\n",
    "print(type(increase))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'Monatery Savings in 2017'\n",
    "print(type(text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = False\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если нужно поменять тип переменной, то полезны функции:\n",
    "\n",
    "- int() - возвращает целочисленную переменную\n",
    "- float() - возвращает нецелочисленную переменную\n",
    "- bool() - возвращает булеву переменную\n",
    "- str() - возвращает строковую переменную"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(savings_2017, type(savings_2017))\n",
    "savings_2017_new = str(savings_2017)\n",
    "print(savings_2017_new, type(savings_2017_new))\n",
    "print('Savings ' +  'in 2017: ' + savings_2017_new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(savings_2017_new) - savings_2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 4\n",
    "\n",
    "Поправьте строчку кода так, чтобы она работала:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I started with $\" + savings + \" and now have $\" + result + \". Not good!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Листы\n",
    "\n",
    "Четыре рассмотренных типа данных устроены так, что в одной переменной записано одно значение:\n",
    "- int: целое число\n",
    "- float: число с дробной частью\n",
    "- str: текст\n",
    "- bool: логическая переменная\n",
    "\n",
    "Например, если мы хотим зафиксировать накопления членов семьи, мы можем создать ряд переменных и вписать туда информацию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings1 = 500\n",
    "savings2 = 1000\n",
    "savings3 = 746\n",
    "savings4 = 456"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Но это не очень удобно, мы можем записать всю информацию в одной переменной:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_family = [500, 1000, 746, 2000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта конструкция называется листом и является отдельным типом данных. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_family = ['mom', 500,'dad', 1000, 'brother', 746, 'me', 2000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А здесь - лист листов :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_family = [['mom', 500], ['dad', 1000], ['brother', 746], ['me', 2000]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 0\n",
    "for member in savings_family:\n",
    "    s = s + member[1]\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(savings_family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 5\n",
    "\n",
    "Создайте лист home, в котором записан название и метраж комнат в доме. Распечатайте лист. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "К элементам листа можно обращаться по индексу:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть много методов (т.е. функций, которые присущи только листам) для работы с листами:\n",
    "\n",
    "Методы\n",
    "- list.append(x)\tДобавляет элемент в конец списка\n",
    "- list.extend(L)\tРасширяет список list, добавляя в конец все элементы списка L\n",
    "- list.insert(i, x)\tВставляет на i-ый элемент значение x\n",
    "- list.remove(x)\tУдаляет первый элемент в списке, имеющий значение x. ValueError, если такого элемента не существует\n",
    "- list.pop([i])\tУдаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент\n",
    "- list.index(x, [start [, end]])\tВозвращает положение первого элемента со значением x (при этом поиск ведется от start до end)\n",
    "- list.count(x)\tВозвращает количество элементов со значением x\n",
    "- list.sort([key=функция])\tСортирует список на основе функции\n",
    "- list.reverse()\tРазворачивает список\n",
    "- list.copy()\tПоверхностная копия списка\n",
    "- list.clear()\tОчищает список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#удаляем запись про последнего члена семьи\n",
    "savings_family.pop()\n",
    "print(savings_family)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#а теперь добавим\n",
    "savings_family.append(['me', 2000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Создайте список из двух списков, в котором хранится информация о сбережениях дяди в 3000 и о сбережениях тети в 10000\n",
    "savings_relatives = [['uncle', 4000], ['aunt', 10000]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_family.extend(savings_relatives)\n",
    "print(savings_family)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 6\n",
    "\n",
    "Посчитайте сумму сбережений всей семьи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for member in savings_family:\n",
    "    ...\n",
    "    print(member)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Основные конструкции языка\n",
    "\n",
    "### Логические выражения\n",
    "\n",
    "По аналогии с арифметическими выражениями существуют логические выражения, которые могут быть истинными или ложными. Простое логическое выражение имеет вид <br /> \n",
    "\n",
    "<арифметическое выражение> <знак сравнения> <арифметическое выражение>. <br /> \n",
    "\n",
    "Например, если у нас есть переменные x и y с какими-то значениями, то логическое выражение <br /> x + y < 3y <br /> в качестве первого арифметического выражения имеет x + y, в качестве знака сравнения < (меньше), а второе арифметическое выражение в нём 3y.\n",
    "\n",
    "<center> \n",
    "    <table>\n",
    "        <tr>\n",
    "            <th>Логическое выражение </th>\n",
    "            <th> Значение </th>\n",
    "        </tr> \n",
    "        <tr><td>&lt;</td><td> Меньше</td></tr>\n",
    "        <tr><td>&gt;</td><td> Больше</td></tr>\n",
    "        <tr><td>&lt;=</td><td> Меньше или равно</td></tr>\n",
    "        <tr><td>&gt;=</td><td> Больше или равно</td></tr>\n",
    "        <tr><td>==</td><td> Равно </td></tr>\n",
    "        <tr><td>!=</td><td> Не равно</td></tr>\n",
    "    </table>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1 > 2\n",
    "print(type(x))\n",
    "print(x)\n",
    "print(int(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы записать сложное логическое выражение, часто бывает необходимо воспользоваться логическими связками \"и\", \"или\" и \"не\". В Питоне они обозначаются как and, or и not соответственно. Операции and и or являеются бинарными, т.е. должны быть записаны между операндами, например x < 3 or y > 2. Операция not - унарная и должна быть записана перед единственным своим операндом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input())\n",
    "y = int(input())\n",
    "z = int(input())\n",
    "print(x == y)\n",
    "print(x > y and y < z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 7\n",
    "\n",
    "Сравните, больше ли x 10. Результат распечатайте"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задача 8**\n",
    "\n",
    "Сбережения мамы попадают в интервал с 300 до 500? Напишите логическое выражение, проверяющее это условие\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_mom = 500\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Условный оператор"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наиболее частое применение логические выражения находят в условных операторах.\n",
    "\n",
    "Синтаксис в питоне: <br />\n",
    "**if** условие1:<br />\n",
    "&emsp; команды<br />\n",
    "**elif** условие2:<br />\n",
    "&emsp; команды<br />\n",
    "**elif** условие3:<br />\n",
    "&emsp; команды<br />\n",
    "**else**: <br />\n",
    "&emsp; команды<br />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 7\n",
    "if x > y:\n",
    "    print('X больше Y')\n",
    "    print(x - y)\n",
    "else:\n",
    "    print(' ')\n",
    "    print('Y не меньше, чем X')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input())\n",
    "y = int(input())\n",
    "if x > y:\n",
    "    print('X больше Y')\n",
    "    print(x - y)\n",
    "elif y > x:\n",
    "    print('Y больше X')\n",
    "    print(y - x)\n",
    "else:\n",
    "    print('X равно Y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задачи 9-10\n",
    "\n",
    "1) Дана площадь кухни. Если она превышает 15 кв.м, то должна появиться строчка \"Кухня большая!\", в противном случае - \"Кухня маленькая\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "room = \"kit\"\n",
    "area = 14.0\n",
    "\n",
    "if :\n",
    "    print()\n",
    "else:\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, а также если он кратен 400."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "if :\n",
    "    print('YES')\n",
    "    \n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цикл while\n",
    "\n",
    "Как только строчка кода выполнилась, она \"забывается\", т.е. чтобы повторить это действие, нужно явно прописать еще раз. Для многократного повторения одних и тех же действий используются циклические конструкции. \n",
    "\n",
    "While переводится как \"пока\" и позволяет выполнять команды, до тех пор, пока условие верно. После окончания выполнения блока команд, относящихся к while, управление возвращается на строку с условием и, если оно выполнено, то выполнение блока команд повторяется, а если не выполнено, то продолжается выполнение команд, записанных после while.\n",
    "\n",
    "Важно случайно не сделать бесконечный цикл!\n",
    "\n",
    "**while** условие1:<br />\n",
    "&emsp; команды<br />\n",
    "\n",
    "Все команды пишутся с отступом. ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# нажать на стоп, чтобы прекратить воспроизведение\n",
    "temperature = 5\n",
    "while temperature > 0:\n",
    "    print('The weather is OK.')\n",
    "    #temperature = temperature - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 11\n",
    "\n",
    "По данному целому числу N распечатайте квадраты всех чисел, предшествующих N (включая N), в порядке убывания\n",
    "\n",
    "**Образец**\n",
    "\n",
    "Входные данные: <br />\n",
    "3\n",
    "\n",
    "Вывод программы: <br />\n",
    "9<br />\n",
    "4<br />\n",
    "1<br />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Цикл for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Функция range(n)\n",
    "Создается объект класса range, внутри которого содержится арифметическая прогрессия в заданных диапазонах и с определенным шагом\n",
    "\n",
    "Ее синтаксис:\n",
    "- range(start, stop[, step])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(range(5))\n",
    "print(list(range(5)))\n",
    "print(list(range(2, 7)))\n",
    "print(list(range(2, 6, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Цикл for\n",
    "Цикл for позволяет поочередно перебрать элементы из чего-нибудь итерируемого.\n",
    "\n",
    "Ее синтаксис: <br />\n",
    "**for** i **in** диапазон изменений i:<br />\n",
    "&emsp; команды\n",
    "\n",
    "Все команды пишутся с отступом"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "for i in range(n + 1):\n",
    "    print(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for color in ['red', 'green', 'yellow']:\n",
    "    print(color, 'apple')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 12\n",
    "\n",
    "Выведите сумму сбережений всех членов семьи из листа savings_family в цикле for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_family"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Написание функций\n",
    "\n",
    "Если какие-то операции надо повторять из раза в раз и нет готовых функций, то можно создать свою. \n",
    "\n",
    "Синтаксис: <br /> \n",
    "**def** название функции(список аргументов):<br /> \n",
    "&emsp; команды<br /> \n",
    "&emsp; **return** результат выполнения функции<br /> \n",
    "\n",
    "Все команды пишутся с отступом. \n",
    "\n",
    "Функция должна быть записана в любом месте до ее первого вызова."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(number, p):\n",
    "    result = number**p\n",
    "    return result\n",
    "\n",
    "number = int(input())\n",
    "p = int(input())\n",
    "print(power(number, p))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "6**5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Задача 13\n",
    "\n",
    "Напишите функцию, которая считает площадь треугольника по трем сторонам. Стороны вводятся вне функции. <br /> \n",
    "Подсказка: используйте формулу Герона\n",
    "$$ S = \\sqrt{p(p-a)(p-b)(p-c)} $$\n",
    "$$ p = \\frac{a + b + c}{2}$$\n",
    "**Образец**\n",
    "\n",
    "Входные данные:<br />\n",
    "3\n",
    "4\n",
    "5\n",
    "\n",
    "Вывод программы: <br />\n",
    "6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square_triangle(a, b, c):\n",
    "    ...\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int(input())\n",
    "b = int(input())\n",
    "c = int(input())\n",
    "print(square_triangle(a, b, c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Основной материал этого файла\n",
    "\n",
    "Наша цель на сегодня: **учиться \"видеть\" данные**. \n",
    "\n",
    "В классе мы будем учиться по датасету **про вина** (приближаем пятницу как можем).\n",
    "Что мы будем делать с винами? \n",
    "\n",
    "Один человек, который собрал данные, предлагает следующее:\n",
    "\n",
    "*After watching Somm (a documentary on master sommeliers) I wondered how I could create a predictive model to identify wines through blind tasting like a master sommelier would. The first step in this journey was gathering some data to train a model. I plan to use deep learning to predict the wine variety using words in the description/review. The model still won't be able to taste the wine, but theoretically it could identify the wine based on a description that a sommelier could give. If anyone has any ideas on how to accomplish this, please post them!*\n",
    "\n",
    "Мы в будущем тоже захотим оценить, а сможем ли по описанию вин узнать их качество и побыть сомелье, основанными на искусственном интеллекте. **Хорошее ли вино? Какую оценку ему поставить? Какую цену?** \n",
    "\n",
    "\n",
    "**!Но до этого нам надо познакомиться с данными - вдруг нам дали какую-то кучку мусора, из которого заказчик хочет прекрасное!**. \n",
    "\n",
    "Можно, конечно, знакомиться с данными в эксель. Но не на курсе DS, даже для новичков :)\n",
    "\n",
    "Помогать будет нам python, а особенно - библиотека pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas. Загрузка библиотек\n",
    "\n",
    " -  <a href=\"http://pandas.pydata.org/\">Pandas</a> - библиотека для обработки и анализа данных. Предназначена для данных разной природы - матричных, панельных данных, временных рядов. Претендует на звание самого мощного и гибкого средства для анализа данных с открытым исходным кодом.\n",
    "\n",
    "\n",
    "Чтобы использовать (любую) библиотеку, нужно подгрузить ее в наш рабочий документ. <br>\n",
    "Команда устроена так:\n",
    "\n",
    "\n",
    "**import** название библиотеки \n",
    "\n",
    "\n",
    "Для дальнейшего использования название библиотеки могут сократить, но тогда в загрузке указывают ее псевдоним\n",
    "\n",
    "\n",
    "**import** название библиотеки **as** псевдоним\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В пандас есть две структуры данных:\n",
    "- Series: одномерный массив с именованными индексами (чаще всего, данные одного типа)\n",
    "- DataFrame: двухмерный массив, имеет табличную структуру, легко изменяется по размерам, может содержать в себе данные разных типов\n",
    "\n",
    "Оба типа можно создавать вручную с помощью функций из самой библиотеки:\n",
    "- pandas.Series(data=None, index=None, dtype=None)\n",
    "- pandas.DataFrame(data=None, index=None, columns=None, dtype=None)\n",
    "\n",
    "- **data** - данные, которые надо записать в структуру\n",
    "- **index** - индексы строк\n",
    "- **columns** - названия столбцов\n",
    "- **dtype** - тип данных\n",
    "\n",
    "Кроме data, остальные параметры опциональны\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы, конечно, можем сами создавать датафреймы!\n",
    "\n",
    "\n",
    "Давайте разберемся, что здесь что и запишем в известную нам конструкцию - листы. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns = ['country', 'province', 'region_1', 'region_2']\n",
    "index = [0, 1, 10, 100]\n",
    "data = [['Italy', 'Sicily & Sardinia', 'Etna', 'NaN'], \n",
    "        ['Portugal', 'Douro', 'NaN', 'NaN'],\n",
    "       ['US', 'California', 'Napa Valley', 'Napa'],\n",
    "       ['US', 'New York', 'Finger Lakes', 'Finger Lakes']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь соберем в датафрейм"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(data, columns = columns, index = index)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 1\n",
    "\n",
    "Создайте датафрейм"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Загрузка и запись данных\n",
    "\n",
    "Правда в том, что мы не будем так жестоко к себе и вручную вбивать данные не будем. А будем загружать из файла. \n",
    "\n",
    "\n",
    "- Функции типа **pd.read_формат** и **pd.to_формат**\n",
    "считывают и записывают данные соответственно. <br /> Полный список можно найти в документации:\n",
    "http://pandas.pydata.org/pandas-docs/stable/io.html\n",
    "\n",
    "Я лично перестала пользоваться экселем даже для беглого смотра данных, потому что на моем ноутбуке файлы больше 50Мб представляют сложности для чтения, а я просматриваю гигабайтные файлы. Pandas грузит их в худшем случае минуту-полторы. \n",
    "\n",
    "Научимся считывать данные в формате csv (comma separated value) функцией:\n",
    "\n",
    "- <a href=\"http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html#pandas.read_csv\"> pd.read_csv()</a>: \n",
    "\n",
    "Аргументов у нее очень много, критически важные:\n",
    " - **filepath_or_buffer** - текстовая строка с названием (адресом) файла\n",
    " - **sep** - разделитель между данными\n",
    " - **header** - номер строки, в которой в файле указаны названия столбцов, None, если нет\n",
    " - **names** - список с названиями колонок\n",
    " - **index_col** - или номер столбца, или список,  или ничего - колонка, из которой надо взять названия строк\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У вас он должен был скачаться под именем: 'dpo_1-2_winemag-data_first150k.csv', поэтому на первом месте вы вписываете ровно вот это название."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('dpo_1-2_winemag-data_first150k.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Смотрим, что загрузилось"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что-то не то с первым столбцом, немного поправим"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('dpo_1-2_winemag-data_first150k.csv', index_col = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Смотрим, что загрузилось:\n",
    "\n",
    "- Посчитаем, сколько записей\n",
    "- Посмотрим, какого типа данные\n",
    "- Проверим, есть ли пропуски"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посчитаем, сколько записей в данных.\n",
    "\n",
    "- Помогает метод **count()**. Это значит, что к любому датафрейму стучимся в гости с этим методом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Метод info() заодно показывает, какого типа данные в столбцах"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Начнем проверять на пропуски! \n",
    "\n",
    "- .isnull() - выдает табличку, где False - ячейка заполнена, True - ячейка пуста :( Ближайшая родня - isna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Немного опережу события и покажу, как оценить масштаб бедствия визуально. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20,12))\n",
    "sns_heatmap = sns.heatmap(data.isnull(), yticklabels=False, cbar=False, cmap='viridis')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что с ним делать?\n",
    "\n",
    "Выбора не очень много: <br>\n",
    "\n",
    "1) Удалять: \n",
    "- dropna(axis=0, how='any'): axis = 0 - удаляем построчно, axis = 1 выкидываем столбец; how ='any' - выкидываем, если есть хотя бы одна ячейка пустая. how = 'all' - выкидываем, если есть полностью пустая строка или столбец\n",
    "\n",
    "2) Вставлять информацию самим:\n",
    "- fillna() - это отдельное искусство, как заполнять. \n",
    "\n",
    "\n",
    "Пока не будем трогать данные. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Описательные статистики\n",
    "\n",
    "Теперь посмотрим, а что содержательно у нас есть на руках. \n",
    "\n",
    "Глазами просматривать не будем, а попросим посчитать основные описательные статистики. Причем сразу все :) \n",
    "\n",
    "- describe() - метод, который возвращает табличку с описательными статистиками. В таком виде считает все для числовых столбцов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Немножко магии, и для нечисловых данные тоже будут свои описательные статистики. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "data.describe(include=['O'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вообще, все можно считать для отдельных колонок. \n",
    "\n",
    "Но мы с вами не изучили, как отбирать колонки. Что ж, время действовать. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Срезы данных\n",
    "\n",
    "Допустим, нам не нужен датасет, а только определенные столбцы или строки или столбцы и строки. \n",
    "\n",
    "\n",
    "Как делать?\n",
    "Помним, что:\n",
    "- у столбцов есть названия\n",
    "- у строк есть названия\n",
    "- если нет названий, то они пронумерованы с нуля\n",
    "\n",
    "Основываясь на этой идее, мы начнем отбирать данные."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.head(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбираем по столбцам. Версия 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[['price','country']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбираем по  строкам. Версия 1. \n",
    "\n",
    "Были бы названия - вместо цифр подставили бы названия и все вышло бы также :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[0:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data[:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбор по столбцам. Версия 2. Все еще по названиям "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[:, ['price']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбор по  строкам. Версия 2. Все еще по названиям "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбор по строчкам и столбцам"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.loc[0:5,['price', 'country']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбор по строчкам и столбцам. Версия 3. По номеру строк и столбцов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "data.iloc[2:5, [5,7]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 6\n",
    "\n",
    "Выберите первую строчку из датасета (вы его создавали в первом задании)\n",
    "\n",
    "## Задача 7\n",
    "\n",
    "Сделайте срез (по номерам строк) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Отбор с условиями\n",
    "\n",
    "Так, а если мне нужны вина дороже $15 долларов? Как быть?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#задаем маску\n",
    "mask = data['price'] > 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#и отбираем данные\n",
    "\n",
    "temp = data[mask]\n",
    "temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 8 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Посмотрим на данные еще раз! Картинками :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Уменьшаем стресс и не идем знакомиться с бибилотеками для визуалиации, потому что...\n",
    "\n",
    "В библиотеке pandas есть инструмент для рисования! \n",
    "\n",
    "- df.plot() - метод для рисования\n",
    "\n",
    "Давайте попробуем  просто вызвать без всего и посмотрим, что выйдет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Не очень."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['price'].plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data['points'].plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что-то все не очень. Давайте попробуем добиться какой-нибудь разумной визуализации столбца points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].value_counts().plot(kind='bar')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А что это новое за value_counts()? (Без него не советую запускать код выше, будет больно)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].value_counts().plot(kind='barh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].value_counts().plot(kind='line')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Опять некрасиво. Потому что у нас индексы не отсортированы при value_counts()!\n",
    "\n",
    "Поправим"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].value_counts().sort_index().plot(kind='line')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].value_counts().sort_index().plot(kind='area')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['points'].sort_index().plot(kind='hist')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data['points'].plot(kind='box')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ну вроде про один столбец разобрались. А как красиво сразу про все столбцы нарисовать?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.plot(kind ='box')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.plot(kind='box', subplots=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А совместно как распределены цены и оценки сомелье?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    " data.plot(x='points', y='price', kind='scatter')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine_counts = pd.read_csv('dpo_1-2_top-five-wine-score-counts.csv')\n",
    "wine_counts.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine_counts.plot.line(x='points')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine_counts.plot.area(x='points')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wine_counts.plot.bar(x='points', stacked=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Домашнее задание №1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Задача 9\n",
    "\n",
    "Нарисовать barplot для столбца 'country' топ-10 стран производителей.\n",
    "\n",
    "1) Нужно взять столбец country <br>\n",
    "2) Применить к нему метод value_counts() <br>\n",
    "3) Потом применить к нему метод sort_index() <br>\n",
    "4) Потом применить к нему метод head(10) <br>\n",
    "5) Потом применить метод plot(kind='bar') <br>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
